Call Unfolding Strategies for Equational Logic Programs

For a programming system based on term rewrite rules such as equational logic programming, a serious eeciency problem of the generated code is the creation of terms that only serve to drive further pattern matching. In this paper, we deene a terminating call unfolding strategy based on ne-grain partial evaluation that removes much of this unnecessary term allocation for programs in intermediate EM code generated from equational logic programs. Our approach is based on calculation, for each instruction , of two sets that reeect the usage of registers in nite execution paths of the program. These sets are calculated using xed-point iteration over the graph representation of the intermediate code. 1 Introduction Finding call unfolding strategies for partial evaluation is an annoying problem. On the one hand, the basic problem| knowing how much unfolding is necessary to expose a particular computation if it occurs|is undecidable. Nearly any recursive deenition can lead to unbounded unfolding by the partial evaluator. On the other hand, there are a great number of common cases when it is clear that a certain amount of unfolding will permit signiicant performance gains. Consider the simple example of an expression g(a; b) + f (a; b) in a functional setting where f (x; y) = g(x; y); unfolding the f call once permits us to share the g call. Caught between possible untermination in the rst case and obviously poor performance in the second, we search for heuristics, terminating strategies that give \good enough" results. In this work we consider call unfolding in the context of equational logic programming. The actual unfolding and partial evaluation is performed on an imperative intermediate language, EM code, but as we will see the strategies depend ercely upon properties of forward-branching equa-tional logic programs and the pattern-matching automata we create for them.